Unit Unipro;


Interface  Uses Tipos;{Unit que contem todos os tipos}
           Procedure  AbreArqs(Var Clientes:TlistaCli; Var Vendedores:TlistaVend;Var Produtos:TlistaPro);
           Procedure  AtuArq(Var Clientes:TlistaCli; Var Vendedores:TlistaVend; Var Produtos:TlistaPro);
           Function   PesqCli(Var Clientes:TlistaCli; Var Cliente:Tcliente):Integer;
           Function   IncluiCli(Var Clientes:TlistaCli; Cliente:Tcliente):Integer;
           Function   AlteraCli(Var Clientes:TlistaCli; Cliente:Tcliente):Integer;
           Function   ExcluiCli(Var Clientes:TlistaCli; Cliente:Tcliente):Integer;
           Procedure  DestroiCli(Var Clientes:TlistaCLi);
           Function   PesqVend(Var Vendedores:TlistaVend; Var Vendedor:Tvendedor):Integer;
           Function   ExcluiVend(Var Vendedores:TlistaVend; Vendedor:Tvendedor):Integer;
           Function   IncluiVend(Var Vendedores:TlistaVend; Vendedor:Tvendedor):Integer;
           Function   AlteraVend(Var Vendedores:TlistaVend; Vendedor:Tvendedor):Integer;
           Procedure  DestroiVend(Var Vendedores:TlistaVend);
           Function   PesqPro(Var Produtos:TlistaPro; Var Produto:Tproduto):Integer;
           Function   IncluiPro(Var Produtos:TlistaPro; Produto:Tproduto):Integer;
           Function   AlteraPro(Var Produtos:TlistaPro; Produto:Tproduto):Integer;
           Function   ExcluiPro(Var Produtos:TlistaPro; Produto:Tproduto):Integer;
           Procedure  DestroiPro(Var Produtos:TlistaPro);
Implementation

{Procedure Para Abertura de Arquivos de Clientes, Vendedores e Produtos}

Procedure  AbreArqs(Var Clientes:TlistaCli; Var Vendedores:TlistaVend;Var Produtos:TlistaPro);

Var
  Cont:Integer;
  Arquivo:Text;

Begin
  {Abertura arquivo de Clientes}

  Clientes.Qtd:=0; {Zerando variavel}
  Cont:=Low(Clientes.C);

  {abrindo arquivo}
  Assign (Arquivo,'ArqCli.TMP');{Variavel assume o arquivo de clientes}

  {$I-}
  Reset(Arquivo);
  {$I+}

  If Ioresult<>0 Then
  Begin
    Rewrite(Arquivo);
  End
  Else
  Begin
    {Lendo de arquivo para vetor}
    While Not(EOF(Arquivo)) Do
    Begin
      With Clientes.C[Cont] Do
      Begin
        Inc(Clientes.Qtd);
        Readln(Arquivo,CodCLi);
        Readln(Arquivo,NomeCLi);
        Inc(Cont);
      End;
    End;
  End;
  Close(Arquivo); {Fechando Arquivo de clientes}

{Abertura do arquivo de vendedores}

  Vendedores.Qtd:=0; {Zerando quantia de vendedores}
  Cont:=Low(Vendedores.C);

  {abrindo arquivo}
  Assign (Arquivo,'ArqVend.TMP');{Variavel assume arquivo de vendedores}

  {$I-}
  Reset(Arquivo);
  {$I+}

  If Ioresult<>0 Then
  Begin
    Rewrite(Arquivo);
  End
  Else
  Begin
    {Lendo de arquivo para vetor}
    While Not(EOF(Arquivo)) Do
    Begin
      With Vendedores.C[Cont] Do
      Begin
        Inc(Vendedores.Qtd);
        Readln(Arquivo,CodVend);
        Readln(Arquivo,NomeVend);
        Inc(Cont);
      End;
    End;
  End;
  Close(Arquivo); {Fechando Arquivo de Vendedores}

{Abertura do arquivo de Produtos}

  Produtos.Qtd:=0; {Zerando quantia de Produtos}
  Cont:=Low(Produtos.C);

  {abrindo arquivo}
  Assign (Arquivo,'ArqPro.TMP');

  {$I-}
  Reset(Arquivo);
  {$I+}

  If Ioresult<>0 Then
  Begin
    Rewrite(Arquivo);
  End
  Else
  Begin
    {Lendo de arquivo para vetor}
    While Not(EOF(Arquivo)) Do
    Begin
      With Produtos.C[Cont] Do
      Begin
        Inc(Produtos.Qtd);
        Readln(Arquivo,CodPro);
        Readln(Arquivo,DesPro);
        Readln(Arquivo,PrePro);
        Readln(Arquivo,QtdEstoquePro);
        Inc(Cont);
      End;
    End;
  End;
  Close(Arquivo); {Fechando Arquivo de Produtos}

End;{Fim da abertura de arquivos e leitura de dados para respectivos vetores}

{____________________________________________________________________________}


{Aqui, a procedure resposavel por atualizar os dados de arquivos de:}
{Cliente,Vendedor e Produto}


Procedure  AtuArq(Var Clientes:TlistaCli; Var Vendedores:TlistaVend; Var Produtos:TlistaPro);
Var
  Cont:Integer;
  Arquivo:Text;
  TdesPro:Integer;
Begin
  {Atualizando Arquivo de Clientes}
  Cont:=0;                     {Zerando variavel contadora}
  Assign(Arquivo,'ArqCli.TMP');{Variavel assume arquivo de clientes}
  Rewrite(Arquivo);            {Sobrescrevendo arquivo com novo arquivo}
  Append(Arquivo);             {Abrindo Arquivo Clientes para escrita}
  For Cont:=Low(Clientes.C) To Clientes.Qtd Do
  Begin{Passagem de dados do vetor para o arquivo}
    With Clientes.C[Cont] Do
    Begin
      Writeln(Arquivo,CodCli:Length(CodCli));
      Writeln(Arquivo,NomeCli:Length(NomeCli));
    End;
  End;
  Close(Arquivo);{Fechando arquivo de Clientes}

  {Atualizando Arquivo de Vendedores}
  Cont:=0;                     {Zerando variavel contadora}
  Assign(Arquivo,'ArqVend.TMP');{Variavel assume arquivo de vendas}
  Rewrite(Arquivo);             {Sobrescrevendo arquivo com novo arquivo}
  Append(Arquivo);              {Abrindo Arquivo de Vendas para escrita}
  For Cont:=Low(Vendedores.C) To Vendedores.Qtd Do
  Begin{Passagem de dados do vetor para o arquivo}
    With Vendedores.C[Cont] Do
    Begin
      Writeln(Arquivo,CodVend:Length(CodVend));
      Writeln(Arquivo,NomeVend:Length(NomeVend));
    End;
  End;
  Close(Arquivo);{Fechando arquivo de Vendedores}

  {Atualizando Arquivo de Produtos}
  Cont:=0;
  Assign(Arquivo,'ArqPro.TMP');{Variavel assume arquivo de Produtos}
  Rewrite(Arquivo);            {Sobrescrevendo arquivo com novo arquivo}
  Append(Arquivo);             {Abrindo Arquivo de Produtos para escrita}
  For Cont:=Low(Produtos.C) To Produtos.Qtd Do
  Begin
    With Produtos.C[Cont] Do
    Begin{Passagem de dados do vetor para o arquivo}
      Writeln(Arquivo,CodPro:Length(CodPro));
      Writeln(Arquivo,DesPro:Length(DesPro));
      Writeln(Arquivo,PrePro:9:2);
      Writeln(Arquivo,QtdEstoquePro:5);
    End;
  End;
  Close(Arquivo);{Fechando arquivo de Produtos}

End;{Fim do procedimento para atualizar arquivos}

{Sub-rotinas de clientes_____________________________________________________}

{Pesquisa}
Function PesqCli(Var Clientes:TlistaCli; Var Cliente:Tcliente):Integer;
Var
  Cont:Integer;
Begin
  {Retornaremos um codigo, sendo os possiveis:}
  {1-Sucesso}
  {2-Lista vazia}
  {3-Inexistente}
  {4-Codigo invalido}

  PesqCli:=3;{Insucesso}

  If Cliente.CodCLi<>'' Then
  Begin{O campo de codigo do cliente nao pode estar vazio}
    If Clientes.Qtd>0 Then{A lista nao pode estar vazia}
    Begin
      For Cont:=Low(Clientes.C) To Clientes.Qtd Do
      Begin{Pesquisando codigo de cliente na lista}
        If Cliente.CodCli=Clientes.C[Cont].CodCli Then
        Begin
          Cliente:=Clientes.C[Cont];{Retornando o cliente}
          Clientes.Pos:=Cont;{Retornando a posicao}
          PesqCli:=1;{Sucesso}
          Break;{Saindo da pesquisa, caso ache algo}
        End;
      End;
    End
    Else
    Begin
      PesqCli:=2{lista vazia}
    End;
  End
  Else
  Begin
    PesqCli:=4;{Codigo invalido}
  End;
End;

{Rotina de inclusao}

Function  IncluiCli(Var Clientes:TlistaCli; Cliente:Tcliente):Integer;
Var
  Cont:integer;
  Result:Integer;
Begin
  Result:=PesqCli(Clientes,Cliente);{Recebe retorno de pesquisa}
  Case Result Of
  2,3:Begin{Nao existente}
      If Clientes.Qtd<MaxCli Then
      Begin{A lista nao pode estar cheia}
        Inc(Clientes.Qtd);{O tamanho da lista e incrementado}
        Clientes.C[Clientes.Qtd]:=Cliente;{Inserindo no proximo espaco livre}
        IncluiCli:=1;{Codigo de sucesso}
      End
      Else
      Begin
        IncluiCli:=2{Lista Cheia}
      End;
    End;
  1: IncluiCli:=3;{Cliente existente}
  4: IncluiCli:=4;{Codigo invalido}
  End;
End;

{Rotina de alteracao}
Function  AlteraCli(Var Clientes:TlistaCli; Cliente:Tcliente):Integer;
Var
  Result:Integer;
  CliTemp:TCliente;
Begin
  CliTemp:=Cliente;
  Result:=PesqCli(Clientes,Cliente);
  Cliente:=CliTemp;{Cliente nao pode ser alterado na pesquisa}

  If Result=1 Then
  Begin{Caso exista na lista}
      Clientes.C[Clientes.Pos]:=Cliente;{Atualizando alteracao}
  End;
  {Retornaremos um codigo, sendo os possiveis:}
  {1-Sucesso}
  {2-Lista vazia}
  {3-Inexistente}
  {4-Codigo invalido}
  AlteraCli:=Result;
End;



{Rotina de exclusao}
Function  ExcluiCli(Var Clientes:TlistaCli; Cliente:Tcliente):Integer;
Var
  Cont:Integer;
  Result:Integer;
Begin
  Result:=PesqCli(Clientes,Cliente);{Retorno da pesquisa}

  If Result=1 Then
  Begin{Sucesso de pesquisa}
    Dec(Clientes.Qtd); {O total da lista e decrementado}
    For Cont:=Clientes.Pos To Clientes.Qtd-1 Do
    Begin              {Exclusao e reorganizacao}
      Clientes.C[Cont]:=Clientes.C[Cont+1];
    End;
  End;
  {Retornaremos um codigo, sendo os possiveis:}
  {1-Sucesso}
  {2-Lista vazia}
  {3-Inexistente}
  {4-Codigo invalido}
  ExcluiCli:=Result;
End;

Procedure  DestroiCli(Var Clientes:TlistaCLi);
Begin
  Clientes.Qtd:=0;
End;


{Fim de operacao com Clientes_______________________________________________}

{Operacoes com vendedores___________________________________________________}

Function PesqVend(Var Vendedores:TlistaVend; Var Vendedor:Tvendedor):Integer;
Var
  Cont:Integer;
Begin
  PesqVend:=3;{Insucesso}

  If Vendedor.CodVend<>'' Then
  Begin{O campo de codigo nao pode estar vazio}
    If Vendedores.Qtd>0 Then{A lista nao pode estar vazia}
    Begin
      For Cont:=Low(Vendedores.C) To Vendedores.Qtd Do
      Begin{Pesquisando codigo na lista}
        If Vendedor.CodVend=Vendedores.C[Cont].CodVend Then
        Begin
          Vendedores.Pos:=Cont;{Retornando a posicao}
          Vendedor:=Vendedores.C[Cont];{Retornando o achado}
          PesqVend:=1;{Sucesso}
          Break;{Saindo da pesquisa, caso ache algo}
        End;
      End;
    End
    Else
    Begin
      PesqVend:=2{lista vazia}
    End;
  End
  Else
  Begin
    PesqVend:=4;{Codigo invalido}
  End;
End;



Function  IncluiVend(Var Vendedores:TlistaVend; Vendedor:Tvendedor):Integer;
Var
  Cont:integer;
  Result:Integer;
Begin
  Result:=PesqVend(Vendedores,Vendedor);{Retorno de pesquisa}

  Case Result Of
  2,3:Begin
      If Vendedores.Qtd<MaxVend Then
      Begin{A lista nao pode estar cheia}
        Inc(Vendedores.Qtd);{O tamanho da lista e incrementado}
        Vendedores.C[Vendedores.Qtd]:=Vendedor;{Inserindo no proximo espaco livre}
        IncluiVend:=1;{Codigo de sucesso}
      End
      Else
      Begin
        IncluiVend:=2{Codigo para lista cheia}
      End;
    End;
  1: IncluiVend:=3;{Vendedor existente}
  4: IncluiVend:=4;{Codigo invalido}
  End;
End;


{Rotina de alteracao}
Function  AlteraVend(Var Vendedores:TlistaVend; Vendedor:Tvendedor):Integer;
Var
  Result:Integer;
  VendedorTemp:Tvendedor;
Begin
  VendedorTemp:=Vendedor;{Vendedor temporario a ser enviado na pesquisa}
                         {Pesquisa nao pode alterar conteudo do novo vendedor}
  Result:=PesqVend(Vendedores,VendedorTemp);{Retorno de pesquisa}

  If Result=1 Then
  Begin
    Vendedores.C[Vendedores.Pos]:=Vendedor;{Atualizando alteracao}
  End;
  {Retornaremos um codigo, sendo os possiveis:}
  {1-Sucesso}
  {2-Lista vazia}
  {3-Inexistente}
  {4-Codigo invalido}
  AlteraVend:=Result;
End;

{Rotina de exclusao}
Function  ExcluiVend(Var Vendedores:TlistaVend; Vendedor:Tvendedor):Integer;
Var
  Cont:Integer;
  Result:Integer;
Begin
  Result:=PesqVend(Vendedores,Vendedor);{Retorno de pesquisa}

  If Result=1 Then
  Begin
    Dec(Vendedores.Qtd); {O total da lista e decrementado}
    For Cont:=Vendedores.Pos To Vendedores.Qtd-1 Do
    Begin            {Exclusao e reorganizacao}
      Vendedores.C[Cont]:=Vendedores.C[Cont+1];
    End;
  End;
  {Retornaremos um codigo, sendo os possiveis:}
  {1-Sucesso}
  {2-Lista vazia}
  {3-Inexistente}
  {4-Codigo invalido}
  ExcluiVend:=Result;
End;

Procedure DestroiVend(Var Vendedores:TlistaVend);
Begin
  Vendedores.Qtd:=0;
End;

{Fim de operacoes relacionadas a vendedores_________________________________}


{Rotinas relacionadas a produtos____________________________________________}

{Pesquisa}
Function PesqPro(Var Produtos:TlistaPro; Var Produto:Tproduto):Integer;
Var
  Cont:Integer;
Begin
  PesqPro:=3;{Insucesso}

  If Produto.CodPro<>'' Then
  Begin{O campo de codigo nao pode estar vazio}
    If Produtos.Qtd>0 Then{A lista nao pode estar vazia}
    Begin
      For Cont:=Low(Produtos.C) To Produtos.Qtd Do
      Begin{Pesquisando codigo na lista}
        If Produto.CodPro=Produtos.C[Cont].CodPro Then
        Begin
          Produtos.Pos:=Cont;{Retornando a posicao}
          Produto:=Produtos.C[Cont];{Retornando o achado}
          PesqPro:=1;{Sucesso}
          Break;{Saindo da pesquisa, caso ache algo}
        End;
      End;
    End
    Else
    Begin
      PesqPro:=2;{lista vazia}
    End;
  End
  Else
  Begin
    PesqPro:=4;{Codigo invalido}
  End;
End;

{Inclusao}
Function  IncluiPro(Var Produtos:TlistaPro; Produto:Tproduto):Integer;
Var
  Cont:integer;
  Result:Integer;
Begin
  Result:=PesqPro(Produtos,Produto);{Retorno de pesquisa}

  Case Result Of
  2,3:Begin
      If Produtos.Qtd<MaxPro Then
      Begin{A lista nao pode estar cheia}
        Inc(Produtos.Qtd);{O tamanho da lista e incrementado}
        Produtos.C[Produtos.Qtd]:=Produto;{Inserindo no proximo espaco livre}
        IncluiPro:=1;{Codigo de sucesso}
      End
      Else
      Begin
        IncluiPro:=2{Codigo para lista cheia}
      End;
    End;
  1: IncluiPro:=3;{Produto existente}
  4: IncluiPro:=4;{Codigo invalido}
  End;
End;


{Rotina de alteracao}
Function  AlteraPro(Var Produtos:TlistaPro; Produto:Tproduto):Integer;
Var
  Result:Integer;
  ProdutoTemp:Tproduto;
Begin
  ProdutoTemp:=Produto;{Produto temporario a ser enviado na pesquisa}
                         {Pesquisa nao pode alterar conteudo do novo vendedor}
  Result:=PesqPro(Produtos,ProdutoTemp);{Retorno de pesquisa}

  If Result=1 Then
  Begin
    Produtos.C[Produtos.Pos]:=Produto;{Atualizando alteracao}
    AlteraPro:=1;{Sucesso na alteracao}
  End;
  {Retornaremos um codigo, sendo os possiveis:}
  {1-Sucesso}
  {2-Lista vazia}
  {3-Inexistente}
  {4-Codigo invalido}
  AlteraPro:=Result;
End;

{Rotina de exclusao}
Function  ExcluiPro(Var Produtos:TlistaPro; Produto:Tproduto):Integer;
Var
  Cont:Integer;
  Result:Integer;
Begin
  Result:=PesqPro(Produtos,Produto);{Retorno de pesquisa}

  If Result=1 Then
  Begin
    Dec(Produtos.Qtd); {O total da lista e decrementado}
    For Cont:=Produtos.Pos To Produtos.Qtd-1 Do
    Begin            {Exclusao e reorganizacao}
      Produtos.C[Cont]:=Produtos.C[Cont+1];
    End;
  End;
  {Retornaremos um codigo, sendo os possiveis:}
  {1-Sucesso}
  {2-Lista vazia}
  {3-Inexistente}
  {4-Codigo invalido}
  ExcluiPro:=Result;
End;

Procedure DestroiPro(Var Produtos:TlistaPro);
Begin
  Produtos.Qtd:=0;
End;

End.

{Fim de operacoes com produtos______________________________________________}

{Fim da Unit}
End.